// 后端API服务 - 与后端接口文档保持一致
import { API_CONFIG } from './config';

/**
 * 统一获取token的工具函数
 * @returns {string} token值
 */
function getToken() {
  return (typeof tt !== 'undefined' ? tt.getStorageSync('token') : uni.getStorageSync('token')) || '';
}

/**
 * 处理401未授权错误，弹出登录弹窗
 */
function handle401Error() {
  console.log('检测到401错误，弹出登录弹窗');
  
  // 动态导入登录弹窗工具
  import('../../utils/loginModal.js').then(({ showLoginModal }) => {
    showLoginModal({
      title: '请先登录',
      content: '登录后才能使用此功能，请先登录您的账号',
      showCancel: true,
      cancelText: '取消',
      confirmText: '去登录'
    });
  }).catch(error => {
    console.error('导入登录弹窗工具失败:', error);
    // 降级处理：直接显示简单提示
    uni.showModal({
      title: '请先登录',
      content: '登录后才能使用此功能',
      showCancel: true,
      cancelText: '取消',
      confirmText: '去登录',
      success: (res) => {
        if (res.confirm) {
          // 跳转到登录页面或触发登录
          uni.$emit('triggerLogin');
        }
      }
    });
  });
}

/**
 * 通用请求方法
 * @param {string} endpoint - API端点
 * @param {object} options - 请求选项
 * @returns {Promise<object>} 响应数据
 */
async function request(endpoint, options = {}) {
  const url = `${API_CONFIG.BASE_URL}${endpoint}`;
  
  // 获取存储的token - 全局自动添加
  const token = getToken();
  
  // 构建请求头，自动添加token
  let header = {
    'Content-Type': 'application/json',
    ...(options.header || {})
  };
  
  // 如果有token，自动添加到header中
  if (token) {
    header['token'] = token;
  }
  
  try {
    const response = await uni.request({
      url,
      method: options.method || 'GET',
      header: header,
      data: options.data,
      timeout: API_CONFIG.TIMEOUT_MS || 600000,
    });

    if (response.statusCode === 200) {
      const result = response.data;
      // 根据后端文档，code为1表示成功，0表示失败
      if (result && result.code === 1) {
        const payload = result.data;
        // 向后兼容：默认返回 data，但附带元信息，避免破坏现有调用方
        if (payload && (typeof payload === 'object' || typeof payload === 'function')) {
          try {
            Object.defineProperty(payload, '__meta', {
              value: { code: result.code, msg: result.msg, raw: result, http: { status: response.statusCode, header: response.header } },
              enumerable: false,
              configurable: false,
              writable: false
            });
          } catch (_) {}
        }
        return payload;
      } else {
        // 返回体非标准或code非1，抛错并携带服务端消息
        const errMsg = (result && result.msg) || `请求失败 (HTTP 200, 非成功code)`;
        throw new Error(errMsg);
      }
    } else if (response.statusCode === 401) {
      // 401未授权错误，触发登录弹窗
      handle401Error();
      throw new Error('未授权，请先登录');
    } else {
      throw new Error(`HTTP ${response.statusCode}: ${response.data?.msg || '请求失败'}`);
    }
  } catch (error) {
    console.error(`API请求失败 [${endpoint}]:`, error);
    throw error;
  }
}

/**
 * 1. 用户登录接口
 * 功能：抖音用户登录，传入 code
 * @param {string} code - 抖音授权码
 * @returns {Promise<object>} 登录结果，包含userId、openid、token
 */
export async function userLogin(code) {
  const result = await request(API_CONFIG.ENDPOINTS.USER_LOGIN, {
    method: 'POST',
    data: { code }
  });
  
  // 保存token到本地存储
  if (result.token) {
    uni.setStorageSync('token', result.token);
    uni.setStorageSync('userId', result.userId);
    uni.setStorageSync('openid', result.openid);
  }
  
  return result;
}

/**
 * 2. 用户上传图片接口
 * 功能：接收用户上传的人物照和看展照，返回图片 ID
 * @param {File} portraitImage - 人物照文件（1张）
 * @param {File[]} exhibitionImages - 看展照文件列表（N张）
 * @returns {Promise<object>} 上传结果
 */
// export async function uploadImages(portraitImage, exhibitionImages) {
//   const formData = new FormData();
//   formData.append('portraitImage', portraitImage);
  
//   if (Array.isArray(exhibitionImages)) {
//     exhibitionImages.forEach((image, index) => {
//       formData.append('exhibitionImages', image);
//     });
//   }
//   console.log(formData);
//   return request(API_CONFIG.ENDPOINTS.UPLOAD_IMAGES, {
//     method: 'POST',
//     header: {
//       'Content-Type': 'multipart/form-data'
//     },
//     data: formData
//   });
// }

/**
 * 2. 用户上传图片接口
 * 功能：接收用户上传的人物照和看展照，返回图片 ID
 * @param {File} portraitImage - 人物照文件（1张）
 * @param {File[]} exhibitionImages - 看展照文件列表（N张）
 * @returns {Promise<object>} 上传结果
 */
export async function uploadImages(portraitImage, exhibitionImages, recordId) {
  console.log('=== 开始批量上传图片 ===');
  console.log('上传参数:', { portraitImage, exhibitionImages, recordId });
  
  // 验证必需参数
  if (!recordId) {
    throw new Error('recordId 是必需参数，不能为 null 或 undefined');
  }
  
  // 检测运行环境，选择合适的上传方式
  const isToutiao = typeof tt !== 'undefined' && tt.uploadFile;
  const isUni = typeof uni !== 'undefined' && uni.uploadFile;
  
  if (!isToutiao && !isUni) {
    throw new Error('当前环境不支持文件上传');
  }
  
  if (isToutiao) {
    // 抖音小程序环境：使用"单文件上传接口"顺序上传（与后端风格化接口配套）
    console.log('🎯 抖音小程序环境，使用单文件上传接口');
    const results = { portraitImageId: null, exhibitionImageIds: [] };

    try {
      // 上传人物照（type=1）
      if (portraitImage) {
        const portraitUri = typeof portraitImage === 'string' ? portraitImage : (portraitImage.path || portraitImage.tempFilePath || portraitImage);
        if (portraitUri) {
          console.log('📸 开始上传人物照:', portraitUri);
          const portraitResult = await uploadSingleImage(portraitUri, 1, recordId);
          results.portraitImageId = portraitResult.imageId;
          console.log('✅ 人物照上传成功:', portraitResult);
        }
      }

      // 上传看展照（type=2）
      if (Array.isArray(exhibitionImages) && exhibitionImages.length > 0) {
        console.log(`📸 开始上传${exhibitionImages.length}张看展照`);
        for (let i = 0; i < exhibitionImages.length; i++) {
          const image = exhibitionImages[i];
          if (!image) continue;
          const exhibitionUri = typeof image === 'string' ? image : (image.path || image.tempFilePath || image);
          if (exhibitionUri) {
            console.log(`📸 上传看展照${i + 1}/${exhibitionImages.length}:`, exhibitionUri);
            const exhibitionResult = await uploadSingleImage(exhibitionUri, 2, recordId);
            results.exhibitionImageIds.push(exhibitionResult.imageId);
            console.log(`✅ 看展照${i + 1}上传成功:`, exhibitionResult);
          }
        }
      }

      console.log('🎉 所有文件上传完成:', results);
      return results;
    } catch (error) {
      console.error('❌ 单文件上传失败:', error);
      throw error;
    }

  } else {
    // 其他环境（如浏览器、微信小程序）：使用原来的多文件上传逻辑
    console.log('其他环境，使用多文件上传接口');
    
    const url = `${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINTS.UPLOAD_IMAGES}`;
    console.log('上传URL:', url);
    
    // 准备上传的文件数组
    const files = [];
    
    // 添加人物照
    if (portraitImage) {
      const portraitUri = typeof portraitImage === 'string' ? portraitImage : 
                         (portraitImage.path || portraitImage.tempFilePath || portraitImage);
      
      console.log('人物照路径处理:', { original: portraitImage, processed: portraitUri });
      
      if (portraitUri) {
        files.push({
          name: 'portraitImage',
          uri: portraitUri
        });
      } else {
        console.error('无法获取人物照路径');
        throw new Error('人物照路径无效');
      }
    }
    
    // 添加看展照
    if (Array.isArray(exhibitionImages)) {
      exhibitionImages.forEach((image, index) => {
        if (image) {
          const exhibitionUri = typeof image === 'string' ? image : 
                               (image.path || image.tempFilePath || image);
          
          console.log(`看展照${index}路径处理:`, { original: image, processed: exhibitionUri });
          
          if (exhibitionUri) {
            files.push({
              name: 'exhibitionImages',
              uri: exhibitionUri
            });
          } else {
            console.error(`无法获取看展照${index}路径`);
          }
        }
      });
    }
    
    const token = getToken();
    console.log('最终上传文件数组:', files);
    
    if (files.length === 0) {
      throw new Error('没有有效的文件路径');
    }
    
    return new Promise((resolve, reject) => {
      // 构建files参数，确保格式完全正确
      const uploadFiles = files.map(file => ({
        name: file.name,
        uri: file.uri
      }));
      
      console.log('构建的files参数:', uploadFiles);
      
      const uploadOptions = {
        url,
        files: uploadFiles,
        fileType: 'image',
        header: {
          'token': token
        },
        formData: {
          type: 'user_upload'
        },
        timeout: API_CONFIG.TIMEOUT_MS || 600000,
        success: (uploadRes) => {
          try {
            console.log('files参数上传响应:', uploadRes);
            const resData = JSON.parse(uploadRes.data);
            if (resData.code === 1) {
              console.log('files参数上传成功:', resData.data);
              resolve(resData.data);
            } else {
              console.error('files参数上传失败，响应:', resData);
              reject(new Error(resData.msg || '上传失败'));
            }
          } catch (e) {
            console.error('响应解析失败:', e, uploadRes);
            reject(new Error('解析响应数据失败'));
          }
        },
        fail: (err) => {
          console.error('files参数上传失败:', err);
          reject(new Error(`上传失败: ${err.errMsg}`));
        }
      };
      
      console.log('files参数上传配置:', uploadOptions);
      uni.uploadFile(uploadOptions);
    });
  }
}

/**
 * Dify 专用：上传单个文件，返回 upload_file_id（不污染全局header）
 * @param {string} filePath 本地文件路径
 * @param {number|string} userId 用户ID
 * @returns {Promise<string>} upload_file_id
 */
export async function difyUploadFile(filePath, userId) {
  const { DIFY } = API_CONFIG;
  
  // 如果是网络URL，先下载到本地
  let localFilePath = filePath;
  if (filePath.startsWith('http://') || filePath.startsWith('https://')) {
    try {
      console.log('下载网络图片到本地:', filePath);
      const downloadResult = await uni.downloadFile({
        url: filePath,
        timeout: API_CONFIG.TIMEOUT_MS || 600000
      });
      localFilePath = downloadResult.tempFilePath;
      console.log('图片下载成功，本地路径:', localFilePath);
    } catch (error) {
      console.error('图片下载失败:', error);
      throw new Error('预设图片下载失败');
    }
  }
  
  return new Promise((resolve, reject) => {
    uni.uploadFile({
      url: `${DIFY.BASE_URL}${DIFY.ENDPOINTS.FILE_UPLOAD}`,
      filePath: localFilePath,
      name: 'file',
      formData: { user: userId || 1 },
      header: { Authorization: `Bearer ${DIFY.API_KEY}` },
      timeout: API_CONFIG.TIMEOUT_MS || 600000,
      success: (res) => {
        try {
          const data = JSON.parse(res.data);
          if (data && data.id) {
            resolve(data.id);
          } else {
            reject(new Error('Dify文件上传返回异常'));
          }
        } catch (e) {
          reject(e);
        }
      },
      fail: (err) => reject(err)
    });
  });
}

/**
 * Dify 专用：创建对话，获取艺术解读（阻塞模式）- 新版本（使用remote_url）
 * @param {object} params
 * @param {string} [params.contextImageUrl] 上下文图片的URL（首次分析时必需）
 * @param {string} params.exhibitionImageUrl 作品图片的URL
 * @param {string|number} params.userId 用户ID
 * @param {boolean} params.useContext 是否使用上下文
 * @param {string} [params.conversationId] 对话ID（继续分析时使用）
 * @returns {Promise<object>} 返回Dify响应（包含 answer / conversation_id 等）
 */
export async function difyCreateChatMessage({ contextImageUrl, exhibitionImageUrl, userId, useContext = true, conversationId = '' }) {
  const { DIFY } = API_CONFIG;
  
  console.log('=== Dify本地API调用开始 ===');
  console.log('API配置:', {
    baseUrl: DIFY.BASE_URL,
    endpoint: DIFY.ENDPOINTS.CHAT_MESSAGES,
    apiKey: DIFY.API_KEY ? '已设置' : '未设置'
  });
  
  // 构建请求体，严格按照接口文档规范
  const body = {
    query: '分析作品',  // 固定查询内容
    inputs: {
      use_context: String(useContext),  // 字符串格式：true/false
      exhibition_image: {
        type: 'image',  // 固定为image
        transfer_method: 'remote_url',  // 使用remote_url传输方式
        url: exhibitionImageUrl  // 作品图片URL
      }
    },
    response_mode: 'blocking',  // 阻塞模式，等待完整响应
    conversation_id: conversationId || '',  // 对话ID，首次分析为空
    user: String(userId || 1)  // 用户ID，字符串格式
  };

  // 首次分析时添加上下文图片
  if (contextImageUrl) {
    console.log('首次分析模式：添加context_image到请求体');
    body.inputs.context_image = {
      type: 'image',  // 固定为image
      transfer_method: 'remote_url',  // 使用remote_url传输方式
      url: contextImageUrl  // 上下文图片URL
    };
  } else {
    console.log('继续分析模式：不添加context_image，使用conversation_id中的已有context');
  }
  
  console.log('请求参数详情:', {
    contextImageUrl: contextImageUrl,
    exhibitionImageUrl: exhibitionImageUrl,
    userId: userId,
    useContext: useContext,
    conversationId: conversationId
  });
  
  console.log('完整请求体:', JSON.stringify(body, null, 2));

  // 重试机制
  const maxRetries = 5;
  let lastError = null;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      console.log(`=== Dify API 请求尝试 ${attempt}/${maxRetries} ===`);
      console.log('请求URL:', `${DIFY.BASE_URL}${DIFY.ENDPOINTS.CHAT_MESSAGES}`);
      console.log('请求头:', {
          'Content-Type': 'application/json',
        'Authorization': `Bearer ${DIFY.API_KEY}`,
          'Connection': 'keep-alive',
          'Accept': 'application/json'
      });
      
      const res = await uni.request({
        url: `${DIFY.BASE_URL}${DIFY.ENDPOINTS.CHAT_MESSAGES}`,  // 完整URL
        method: 'POST',  // POST方法
        header: {
          'Content-Type': 'application/json',  // JSON格式
          Authorization: `Bearer ${DIFY.API_KEY}`,  // Bearer token认证
          'Connection': 'keep-alive',  // 保持连接
          'Accept': 'application/json'  // 接受JSON响应
        },
        data: body,  // 请求体数据
        timeout: 300000, // 5分钟超时
      });

      console.log('响应状态码:', res.statusCode);
      console.log('响应头:', res.header);

      if (res.statusCode >= 200 && res.statusCode < 300) {
        console.log('✅ Dify API 请求成功');
        console.log('响应数据结构:', {
          hasAnswer: !!(res.data && res.data.answer),
          hasConversationId: !!(res.data && res.data.conversation_id),
          hasMetadata: !!(res.data && res.data.metadata),
          answerLength: res.data?.answer?.length || 0
        });
        console.log('完整响应数据:', res.data);
        
        // 检查响应格式，确保包含answer字段
        if (res.data && res.data.answer) {
          console.log('✅ 响应格式正确，返回数据');
          return res.data;
        } else {
          console.error('❌ 响应格式异常，缺少answer字段');
          console.error('实际响应:', res.data);
          throw new Error('Dify API 响应格式异常，缺少 answer 字段');
        }
      }
      
      // 添加详细的错误信息
      console.error('Dify API 请求失败，状态码:', res.statusCode);
      console.error('Dify API 错误响应:', res.data);
      console.error('Dify API 请求体:', body);
      
      throw new Error(`Dify 对话失败: HTTP ${res.statusCode} - ${JSON.stringify(res.data)}`);
      
    } catch (error) {
      lastError = error;
      console.error(`Dify API 请求失败 (尝试 ${attempt}/${maxRetries}):`, error);
      
      // 检查是否是HTTP/2流终止错误
      if (error.errMsg && error.errMsg.includes('HTTP/2 stream')) {
        console.log('检测到HTTP/2流终止错误，增加重试间隔');
        if (attempt < maxRetries) {
          const waitTime = attempt * 5000; // 增加等待时间：5秒、10秒、15秒
          console.log(`等待 ${waitTime}ms 后重试...`);
          await new Promise(resolve => setTimeout(resolve, waitTime));
        }
      } else {
        // 其他错误使用原来的重试逻辑
        if (attempt < maxRetries) {
          const waitTime = attempt * 2000;
          console.log(`等待 ${waitTime}ms 后重试...`);
          await new Promise(resolve => setTimeout(resolve, waitTime));
        }
      }
    }
  }

  // 所有重试都失败了
  console.error('Dify API 所有重试都失败了');
  throw new Error(`Dify 对话失败: ${lastError?.errMsg || lastError?.message || '网络连接问题'}`);
}

/**
 * Dify 专用：创建对话，获取艺术解读（阻塞模式）- 原版本（使用local_file，已注释）
 * @param {object} params
 * @param {string} [params.contextUploadId] 上下文图片的 upload_file_id（首次分析时必需）
 * @param {string} params.exhibitionUploadId 作品图片的 upload_file_id
 * @param {string|number} params.userId 用户ID
 * @param {boolean} params.useContext 是否使用上下文
 * @param {string} [params.conversationId] 对话ID（继续分析时使用）
 * @returns {Promise<object>} 返回Dify响应（包含 answer / conversation_id 等）
 */
// export async function difyCreateChatMessageOld({ contextUploadId, exhibitionUploadId, userId, useContext = true, conversationId = '' }) {
//   const { DIFY } = API_CONFIG;
//   const body = {
//     query: '分析作品',
//     inputs: {
//       use_context: String(useContext),
//       exhibition_image: {
//         type: 'image',
//         transfer_method: 'local_file',
//         upload_file_id: exhibitionUploadId
//       }
//     },
//     response_mode: 'blocking',  // 改为blocking模式，避免流式处理复杂性
//     conversation_id: conversationId || '',
//     user: String(userId || 1),
//     files: [
//       { type: 'image', transfer_method: 'local_file', upload_file_id: exhibitionUploadId }
//     ]
//   };

//   // 如果是首次分析（有contextUploadId），则添加context_image
//   console.log('Dify API 参数检查:', {
//     contextUploadId: contextUploadId,
//     exhibitionUploadId: exhibitionUploadId,
//     useContext: useContext,
//     conversationId: conversationId
//   })
  
//   if (contextUploadId) {
//     console.log('首次分析：添加context_image到请求体')
//     body.inputs.context_image = {
//       type: 'image',
//       transfer_method: 'local_file',
//       upload_file_id: contextUploadId
//     };
//     body.files.push({ type: 'image', transfer_method: 'local_file', upload_file_id: contextUploadId });
//   } else {
//     console.log('继续分析：不添加context_image，use_context=false，使用conversation_id中的已有context')
//   }
  
//   console.log('最终请求体:', JSON.stringify(body, null, 2))

//   // 重试机制
//   const maxRetries = 5;
//   let lastError = null;

//   for (let attempt = 1; attempt <= maxRetries; attempt++) {
//     try {
//       console.log(`Dify API 请求尝试 ${attempt}/${maxRetries}`);
      
//       const res = await uni.request({
//         url: `${DIFY.BASE_URL}${DIFY.ENDPOINTS.CHAT_MESSAGES}`,
//         method: 'POST',
//         header: {
//           'Content-Type': 'application/json',
//           Authorization: `Bearer ${DIFY.API_KEY}`,
//           'Connection': 'keep-alive',
//           'Accept': 'application/json'
//         },
//         data: body,
//         timeout: 300000, // 减少超时时间到5分钟，避免HTTP/2流终止
//       });

//       if (res.statusCode >= 200 && res.statusCode < 300) {
//         console.log('Dify API 请求成功');
//         console.log('Dify API 响应数据:', res.data);
        
//         // 检查响应格式
//         if (res.data && res.data.answer) {
//           return res.data;
//         } else {
//           console.error('Dify API 响应格式异常:', res.data);
//           throw new Error('Dify API 响应格式异常，缺少 answer 字段');
//         }
//       }
      
//       // 添加详细的错误信息
//       console.error('Dify API 请求失败，状态码:', res.statusCode);
//       console.error('Dify API 错误响应:', res.data);
//       console.error('Dify API 请求体:', body);
      
//       throw new Error(`Dify 对话失败: HTTP ${res.statusCode} - ${JSON.stringify(res.data)}`);
      
//     } catch (error) {
//       lastError = error;
//       console.error(`Dify API 请求失败 (尝试 ${attempt}/${maxRetries}):`, error);
      
//       // 检查是否是HTTP/2流终止错误
//       if (error.errMsg && error.errMsg.includes('HTTP/2 stream')) {
//         console.log('检测到HTTP/2流终止错误，增加重试间隔');
//         if (attempt < maxRetries) {
//           const waitTime = attempt * 5000; // 增加等待时间：5秒、10秒、15秒
//           console.log(`等待 ${waitTime}ms 后重试...`);
//           await new Promise(resolve => setTimeout(resolve, waitTime));
//         }
//       } else {
//         // 其他错误使用原来的重试逻辑
//         if (attempt < maxRetries) {
//           const waitTime = attempt * 2000;
//           console.log(`等待 ${waitTime}ms 后重试...`);
//           await new Promise(resolve => setTimeout(resolve, waitTime));
//         }
//       }
//     }
//   }

//   // 所有重试都失败了
//   console.error('Dify API 所有重试都失败了');
//   throw new Error(`Dify 对话失败: ${lastError?.errMsg || lastError?.message || '网络连接问题'}`);
// }

/**
 * 3. 用户单文件上传图片接口（V2版本）
 * 功能：接收用户上传的单文件图片，返回图片 ID。需额外传入recordId绑定对应的展览记录。
 * @param {string} imagePath - 图片文件路径
 * @param {number} imageType - 图片类型：1=人物照，2=看展照
 * @param {string} recordId - 展览记录ID，用于绑定图片到特定展览（必需参数）
 * @returns {Promise<object>} 上传结果，包含imageId和imageUrl
 */
export async function uploadSingleImage(imagePath, imageType, recordId) {
  console.log('=== 开始单文件上传 ===');
  console.log('上传参数:', { imagePath, imageType, recordId });
  
  // 验证必需参数
  if (!recordId) {
    throw new Error('recordId 是必需参数，不能为 null 或 undefined');
  }
  
  const token = getToken();
  
  return new Promise((resolve, reject) => {
    const uploadOptions = {
      url: `${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINTS.SINGLE_IMAGE_UPLOAD}`,
      filePath: imagePath,
      name: 'image',
      fileType: 'image',
      header: {
        'token': token
      },
      formData: {
        imageType: imageType,
        recordId: recordId // 必需参数，始终添加到formData
      },
      timeout: API_CONFIG.TIMEOUT_MS || 600000,
      success: (uploadRes) => {
        try {
          console.log('单文件上传响应:', uploadRes);
          const resData = JSON.parse(uploadRes.data);
          if (resData.code === 1) {
            console.log('✅ 单文件上传成功:', resData.data);
            console.log('图片ID:', resData.data.imageId);
            console.log('图片URL:', resData.data.imageUrl);
            resolve(resData.data);
          } else {
            console.error('❌ 单文件上传失败，响应:', resData);
            reject(new Error(resData.msg || '上传失败'));
          }
        } catch (e) {
          console.error('❌ 单文件上传响应解析失败:', e, uploadRes);
          reject(new Error('解析响应数据失败'));
        }
      },
      fail: (err) => {
        console.error('❌ 单文件上传失败:', err);
        reject(new Error(`上传失败: ${err.errMsg}`));
      }
    };

    console.log('单文件上传配置:', uploadOptions);
    
    // 检测运行环境，选择合适的上传API
    const isToutiao = typeof tt !== 'undefined' && tt.uploadFile;
    const uploadAPI = isToutiao ? tt.uploadFile : uni.uploadFile;
    
    console.log('使用上传API:', isToutiao ? 'tt.uploadFile' : 'uni.uploadFile');
    uploadAPI(uploadOptions);
  });
}

/**
 * 4. 图片分析接口
 * 功能：对上传的图片进行分析，生成人物特征和艺术风格描述
 * @param {number} portraitImageId - 人物照ID
 * @param {number[]} exhibitionImageIds - 看展照ID列表
 * @returns {Promise<object>} 分析结果
 */
export async function imageAnalysis(portraitImageId, exhibitionImageIds) {
  return request(API_CONFIG.ENDPOINTS.IMAGE_ANALYSIS, {
    method: 'POST',
    header: {
      'Content-Type': 'application/json' ,// 修改为正确的Content-Type
    },
    data: {
      portraitImageId,
      exhibitionImageIds: Array.isArray(exhibitionImageIds) ? exhibitionImageIds : [exhibitionImageIds]
    }
  });
}

/**
 * 5. 生成风格化图片接口
 * 功能：基于分析结果生成 4 张风格化图片
 * @param {number} analysisId - 分析ID
 * @returns {Promise<object>} 生成的图片信息
 */
export async function generateImages(analysisId) {
  return request(API_CONFIG.ENDPOINTS.GENERATE_IMAGES, {
    method: 'POST',
    data: {
      analysisId
    }
  });
}

/**
 * 6. 用户选择图片接口
 * 功能：记录用户选中的 1 张风格化图片
 * @param {number} genImageId - 生成的图片ID
 * @returns {Promise<object>} 选择结果
 */
export async function selectImage(genImageId) {
  return request(API_CONFIG.ENDPOINTS.SELECT_IMAGE, {
    method: 'POST',
    data: {
      genImageId
    }
  });
}

/**
 * 7. 生成文本接口
 * 功能：基于用户选择的图片生成简介和朋友圈文案
 * @param {number} selectionId - 选择ID
 * @returns {Promise<object>} 生成的文本内容
 */
export async function generateText(selectionId) {
  return request(API_CONFIG.ENDPOINTS.GENERATE_TEXT, {
    method: 'POST',
    data: {
      selectionId
    }
  });
}

/**
 * 8. 创建视频生成任务接口
 * 功能：触发视频生成任务（异步），返回任务 ID
 * @param {number} selectionId - 选择ID
 * @param {number} refImageId - 参考图片ID
 * @returns {Promise<object>} 任务信息 {taskId, status}
 */
export async function createVideoTask(selectionId, refImageId) {
  try {
    const response = await request(API_CONFIG.ENDPOINTS.CREATE_VIDEO_TASK, {
      method: 'POST',
      data: {
        selectionId,
        refImageId
      }
    });

    // response 已经是 { taskId, status }
    console.log('createVideoTask 请求返回结果:', response)
    console.log('createVideoTask response.taskId:', response.taskId)
    console.log('createVideoTask response.data?.taskId:', response.data?.taskId) 

    if (!response.taskId || !response.status) {
      throw new Error('返回数据缺少 taskId 或 status');
    }

    return response;  // 直接返回，不要再 .data
  } catch (error) {
    console.error('createVideoTask 错误:', error);
    throw error;
  }
}


/**
 * 9. 查询视频任务状态接口
 * 功能：查询视频生成任务的实时状态
 * @param {number} taskId - 任务ID
 * @returns {Promise<object>} 任务状态 {taskId, status, videoUrl, errorMsg, updateTime}
 */
export async function queryVideoTask(taskId) {
  const res = await request(`${API_CONFIG.ENDPOINTS.QUERY_VIDEO_TASK}?taskId=${taskId}`, {
      method: 'GET'
    });
    console.log('queryVideoTask 返回结果:', res);
  
    // 如果 request 已经帮你解开了 data，那么直接返回 res
    // 否则返回 res.data，保证外部用起来统一
    return res.data ? res.data : res;
}

/**
 * 轮询查询视频任务状态
 * @param {number} taskId - 任务ID
 * @param {number} interval - 轮询间隔（毫秒）
 * @param {number} maxAttempts - 最大尝试次数
 * @returns {Promise<object>} 最终任务状态
 */
// backendApi.js

export async function pollVideoTaskStatus(taskId, interval = 5000, maxRetries = 300) {
  if (!taskId) {
    throw new Error('无效的 taskId，无法查询视频任务状态')
  }

  let retries = 0
  while (retries < maxRetries) {
    try {
      const res = await queryVideoTask(taskId)
      const status = res.status
      if (status === 3 || status === 4) {
        return res
      }

    } catch (err) {
      //console.error('轮询任务状态失败:', err)
      // 出现请求错误，直接停止，不再继续轮询
      throw err
    }

    // 等待一段时间再重试
    await new Promise(r => setTimeout(r, interval))
    retries++
  }

  throw new Error('轮询超时，任务未完成')
}

/**
 * 展览分析API
 * 功能：分析展览照片和文本信息，返回艺术解读结果
 * @param {object} analysisData - 分析数据 { photos: [{imageId, type}], text?: string }
 * @returns {Promise<object>} 分析结果
 */
export async function analyzeExhibition(analysisData) {
  console.log('📤 [Exhibition] 提交分析数据:', analysisData)
  try {
    const res = await request(API_CONFIG.ENDPOINTS.EXHIBITION_ANALYZE, {
      method: 'POST',
      header: { 'Content-Type': 'application/json' },
      data: analysisData
    })
    console.log('✅ [Exhibition] 分析结果返回:', res)
    return res
  } catch (error) {
    console.error('❌ [Exhibition] 分析失败:', error)
    throw error
  }
}

/**
 * 检查用户是否已登录
 * @returns {boolean} 是否已登录
 */
export function isLoggedIn() {
  const token = getToken();
  return !!token;
}

/**
 * 获取当前用户ID
 * @returns {number|null} 用户ID
 */
export function getCurrentUserId() {
  return (typeof tt !== 'undefined' ? tt.getStorageSync('userId') : uni.getStorageSync('userId'));
}

/**
 * 退出登录
 */
export function logout() {
  uni.removeStorageSync('token');
  uni.removeStorageSync('userId');
  uni.removeStorageSync('openid');
}

// ==================== V2版本 - 看展记录相关接口 ====================

/**
 * 6. 新建看展记录
 * 功能：手动新建看展记录
 * @param {object} recordData - 看展记录数据
 * @param {string} recordData.title - 展览名称
 * @param {string} recordData.galleryName - 美术馆名称
 * @param {string} recordData.exhibitionDate - 看展日期（格式 "YYYY-MM-DD"，默认当前日期）
 * @param {string} recordData.country - 国家
 * @param {string} recordData.city - 城市
 * @param {string} recordData.artist - 艺术家
 * @param {string} recordData.styleTags - 风格标签，英文逗号分割
 * @param {string} recordData.notes - 观展感想
 * @param {string} recordData.aiSummary - ai总结
 * @returns {Promise<object>} 返回结果，包含recordId
 */
export async function createRecord(recordData) {
  return request(API_CONFIG.ENDPOINTS.CREATE_RECORD, {
    method: 'POST',
    data: recordData
  });
}

/**
 * 7. 编辑看展记录
 * 功能：编辑已有看展记录信息（只填希望修改的部分即可）
 * @param {object} recordData - 看展记录数据
 * @param {string} recordData.recordId - 看展记录ID
 * @param {string} [recordData.title] - 展览名称
 * @param {string} [recordData.galleryName] - 美术馆名称
 * @param {string} [recordData.exhibitionDate] - 看展日期（格式 "YYYY-MM-DD"）
 * @param {string} [recordData.country] - 国家
 * @param {string} [recordData.city] - 城市
 * @param {string} [recordData.artist] - 艺术家
 * @param {string} [recordData.styleTags] - 风格标签，逗号分割
 * @param {string} [recordData.notes] - 观展感想
 * @param {string} [recordData.aiSummary] - ai总结
 * @param {string} [recordData.coverImageUrl] - 封面图片URL
 * @returns {Promise<object>} 返回结果
 */
export async function updateRecord(recordData) {
  return request(API_CONFIG.ENDPOINTS.UPDATE_RECORD, {
    method: 'PUT',
    data: recordData
  });
}

/**
 * 8. 删除看展记录中的图片
 * 功能：删除看展记录中的指定图片
 * @param {string} recordId - 展览id
 * @param {string} imageId - 图片id
 * @returns {Promise<object>} 返回结果
 */
export async function deleteRecordImage(recordId, imageId) {
  return request(API_CONFIG.ENDPOINTS.DELETE_RECORD_IMAGE, {
    method: 'DELETE',
    data: {
      recordId,
      imageId
    }
  });
}

/**
 * 9. 删除看展记录
 * 功能：删除整个看展记录
 * @param {string} recordId - 展览id
 * @returns {Promise<object>} 返回结果
 */
export async function deleteRecord(recordId) {
  return request(API_CONFIG.ENDPOINTS.DELETE_RECORD, {
    method: 'DELETE',
    data: {
      recordId
    }
  });
}

/**
 * 10. 获取看展记录列表
 * 功能：获取看展记录列表，支持分页
 * @param {number} pageNum - 页码（从0开始）
 * @param {number} pageSize - 每页数量
 * @returns {Promise<object>} 返回结果，包含total和records列表
 */
export async function getRecordList(pageNum = 0, pageSize = 10) {
  return request(`${API_CONFIG.ENDPOINTS.GET_RECORD_LIST}?pageNum=${pageNum}&pageSize=${pageSize}`, {
    method: 'GET'
  });
}

/**
 * 11. 获取看展记录详情
 * 功能：获取看展记录详情（含图片瀑布流），图片列表按 "收藏置顶 + 时间倒序" 排序
 * @param {string} recordId - 看展记录ID
 * @returns {Promise<object>} 返回结果，包含recordInfo和imageList
 */
export async function getRecordDetail(recordId) {
  return request(`${API_CONFIG.ENDPOINTS.GET_RECORD_DETAIL}?recordId=${recordId}`, {
    method: 'GET'
  });
}

/**
 * 12. 图片收藏/取消收藏
 * 功能：图片收藏或取消收藏
 * @param {string} imageId - 图片ID
 * @param {number} isFavorite - 0=未收藏，1=已收藏
 * @returns {Promise<object>} 返回结果
 */
export async function toggleImageFavorite(imageId, isFavorite) {
  return request(API_CONFIG.ENDPOINTS.IMAGE_FAVORITE, {
    method: 'POST',
    data: {
      imageId,
      isFavorite
    }
  });
}